home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / markupbase.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  9KB  |  395 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Shared support for scanning document type declarations in HTML and XHTML.
  5.  
  6. This module is used as a foundation for the HTMLParser and sgmllib
  7. modules (indirectly, for htmllib as well).  It has no documented
  8. public API and should not be used directly.
  9.  
  10. '''
  11. import re
  12. _declname_match = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*\\s*').match
  13. _declstringlit_match = re.compile('(\\\'[^\\\']*\\\'|"[^"]*")\\s*').match
  14. _commentclose = re.compile('--\\s*>')
  15. _markedsectionclose = re.compile(']\\s*]\\s*>')
  16. _msmarkedsectionclose = re.compile(']\\s*>')
  17. del re
  18.  
  19. class ParserBase:
  20.     '''Parser base class which provides some common support methods used
  21.     by the SGML/HTML and XHTML parsers.'''
  22.     
  23.     def __init__(self):
  24.         if self.__class__ is ParserBase:
  25.             raise RuntimeError('markupbase.ParserBase must be subclassed')
  26.         
  27.  
  28.     
  29.     def error(self, message):
  30.         raise NotImplementedError('subclasses of ParserBase must override error()')
  31.  
  32.     
  33.     def reset(self):
  34.         self.lineno = 1
  35.         self.offset = 0
  36.  
  37.     
  38.     def getpos(self):
  39.         '''Return current line number and offset.'''
  40.         return (self.lineno, self.offset)
  41.  
  42.     
  43.     def updatepos(self, i, j):
  44.         if i >= j:
  45.             return j
  46.         
  47.         rawdata = self.rawdata
  48.         nlines = rawdata.count('\n', i, j)
  49.         if nlines:
  50.             self.lineno = self.lineno + nlines
  51.             pos = rawdata.rindex('\n', i, j)
  52.             self.offset = j - pos + 1
  53.         else:
  54.             self.offset = self.offset + j - i
  55.         return j
  56.  
  57.     _decl_otherchars = ''
  58.     
  59.     def parse_declaration(self, i):
  60.         rawdata = self.rawdata
  61.         j = i + 2
  62.         if not rawdata[i:j] == '<!':
  63.             raise AssertionError, 'unexpected call to parse_declaration'
  64.         if rawdata[j:j + 1] in ('-', ''):
  65.             return -1
  66.         
  67.         n = len(rawdata)
  68.         if rawdata[j:j + 1] == '--':
  69.             return self.parse_comment(i)
  70.         elif rawdata[j] == '[':
  71.             return self.parse_marked_section(i)
  72.         else:
  73.             (decltype, j) = self._scan_name(j, i)
  74.         if j < 0:
  75.             return j
  76.         
  77.         if decltype == 'doctype':
  78.             self._decl_otherchars = ''
  79.         
  80.         while j < n:
  81.             c = rawdata[j]
  82.             if c == '>':
  83.                 data = rawdata[i + 2:j]
  84.                 if decltype == 'doctype':
  85.                     self.handle_decl(data)
  86.                 else:
  87.                     self.unknown_decl(data)
  88.                 return j + 1
  89.             
  90.             if c in '"\'':
  91.                 m = _declstringlit_match(rawdata, j)
  92.                 if not m:
  93.                     return -1
  94.                 
  95.                 j = m.end()
  96.             elif c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
  97.                 (name, j) = self._scan_name(j, i)
  98.             elif c in self._decl_otherchars:
  99.                 j = j + 1
  100.             elif c == '[':
  101.                 if decltype == 'doctype':
  102.                     j = self._parse_doctype_subset(j + 1, i)
  103.                 elif decltype in ('attlist', 'linktype', 'link', 'element'):
  104.                     self.error("unsupported '[' char in %s declaration" % decltype)
  105.                 else:
  106.                     self.error("unexpected '[' char in declaration")
  107.             else:
  108.                 self.error('unexpected %r char in declaration' % rawdata[j])
  109.             if j < 0:
  110.                 return j
  111.                 continue
  112.         return -1
  113.  
  114.     
  115.     def parse_marked_section(self, i, report = 1):
  116.         rawdata = self.rawdata
  117.         if not rawdata[i:i + 3] == '<![':
  118.             raise AssertionError, 'unexpected call to parse_marked_section()'
  119.         (sectName, j) = self._scan_name(i + 3, i)
  120.         if j < 0:
  121.             return j
  122.         
  123.         if sectName in ('temp', 'cdata', 'ignore', 'include', 'rcdata'):
  124.             match = _markedsectionclose.search(rawdata, i + 3)
  125.         elif sectName in ('if', 'else', 'endif'):
  126.             match = _msmarkedsectionclose.search(rawdata, i + 3)
  127.         else:
  128.             self.error('unknown status keyword %r in marked section' % rawdata[i + 3:j])
  129.         if not match:
  130.             return -1
  131.         
  132.         if report:
  133.             j = match.start(0)
  134.             self.unknown_decl(rawdata[i + 3:j])
  135.         
  136.         return match.end(0)
  137.  
  138.     
  139.     def parse_comment(self, i, report = 1):
  140.         rawdata = self.rawdata
  141.         if rawdata[i:i + 4] != '<!--':
  142.             self.error('unexpected call to parse_comment()')
  143.         
  144.         match = _commentclose.search(rawdata, i + 4)
  145.         if not match:
  146.             return -1
  147.         
  148.         if report:
  149.             j = match.start(0)
  150.             self.handle_comment(rawdata[i + 4:j])
  151.         
  152.         return match.end(0)
  153.  
  154.     
  155.     def _parse_doctype_subset(self, i, declstartpos):
  156.         rawdata = self.rawdata
  157.         n = len(rawdata)
  158.         j = i
  159.         while j < n:
  160.             c = rawdata[j]
  161.             if c == '<':
  162.                 s = rawdata[j:j + 2]
  163.                 if s == '<':
  164.                     return -1
  165.                 
  166.                 if s != '<!':
  167.                     self.updatepos(declstartpos, j + 1)
  168.                     self.error('unexpected char in internal subset (in %r)' % s)
  169.                 
  170.                 if j + 2 == n:
  171.                     return -1
  172.                 
  173.                 if j + 4 > n:
  174.                     return -1
  175.                 
  176.                 if rawdata[j:j + 4] == '<!--':
  177.                     j = self.parse_comment(j, report = 0)
  178.                     if j < 0:
  179.                         return j
  180.                         continue
  181.                     continue
  182.                 
  183.                 (name, j) = self._scan_name(j + 2, declstartpos)
  184.                 if j == -1:
  185.                     return -1
  186.                 
  187.                 if name not in ('attlist', 'element', 'entity', 'notation'):
  188.                     self.updatepos(declstartpos, j + 2)
  189.                     self.error('unknown declaration %r in internal subset' % name)
  190.                 
  191.                 meth = getattr(self, '_parse_doctype_' + name)
  192.                 j = meth(j, declstartpos)
  193.                 if j < 0:
  194.                     return j
  195.                 
  196.             j < 0
  197.             if c == '%':
  198.                 if j + 1 == n:
  199.                     return -1
  200.                 
  201.                 (s, j) = self._scan_name(j + 1, declstartpos)
  202.                 if j < 0:
  203.                     return j
  204.                 
  205.                 if rawdata[j] == ';':
  206.                     j = j + 1
  207.                 
  208.             rawdata[j] == ';'
  209.             if c == ']':
  210.                 j = j + 1
  211.                 while j < n and rawdata[j].isspace():
  212.                     j = j + 1
  213.                 if j < n:
  214.                     if rawdata[j] == '>':
  215.                         return j
  216.                     
  217.                     self.updatepos(declstartpos, j)
  218.                     self.error('unexpected char after internal subset')
  219.                 else:
  220.                     return -1
  221.             j < n
  222.             if c.isspace():
  223.                 j = j + 1
  224.                 continue
  225.             self.updatepos(declstartpos, j)
  226.             self.error('unexpected char %r in internal subset' % c)
  227.         return -1
  228.  
  229.     
  230.     def _parse_doctype_element(self, i, declstartpos):
  231.         (name, j) = self._scan_name(i, declstartpos)
  232.         if j == -1:
  233.             return -1
  234.         
  235.         rawdata = self.rawdata
  236.         if '>' in rawdata[j:]:
  237.             return rawdata.find('>', j) + 1
  238.         
  239.         return -1
  240.  
  241.     
  242.     def _parse_doctype_attlist(self, i, declstartpos):
  243.         rawdata = self.rawdata
  244.         (name, j) = self._scan_name(i, declstartpos)
  245.         c = rawdata[j:j + 1]
  246.         if c == '':
  247.             return -1
  248.         
  249.         if c == '>':
  250.             return j + 1
  251.         
  252.         while None:
  253.             (name, j) = self._scan_name(j, declstartpos)
  254.             if j < 0:
  255.                 return j
  256.             
  257.             c = rawdata[j:j + 1]
  258.             if c == '':
  259.                 return -1
  260.             
  261.             if c == '(':
  262.                 if ')' in rawdata[j:]:
  263.                     j = rawdata.find(')', j) + 1
  264.                 else:
  265.                     return -1
  266.                 while rawdata[j:j + 1].isspace():
  267.                     j = j + 1
  268.                 if not rawdata[j:]:
  269.                     return -1
  270.                 
  271.             else:
  272.                 (name, j) = self._scan_name(j, declstartpos)
  273.             c = rawdata[j:j + 1]
  274.             if not c:
  275.                 return -1
  276.             
  277.             if c in '\'"':
  278.                 m = _declstringlit_match(rawdata, j)
  279.                 if m:
  280.                     j = m.end()
  281.                 else:
  282.                     return -1
  283.                 c = rawdata[j:j + 1]
  284.                 if not c:
  285.                     return -1
  286.                 
  287.             
  288.             if c == '#':
  289.                 if rawdata[j:] == '#':
  290.                     return -1
  291.                 
  292.                 (name, j) = self._scan_name(j + 1, declstartpos)
  293.                 if j < 0:
  294.                     return j
  295.                 
  296.                 c = rawdata[j:j + 1]
  297.                 if not c:
  298.                     return -1
  299.                 
  300.             
  301.             if c == '>':
  302.                 return j + 1
  303.                 continue
  304.  
  305.     
  306.     def _parse_doctype_notation(self, i, declstartpos):
  307.         (name, j) = self._scan_name(i, declstartpos)
  308.         if j < 0:
  309.             return j
  310.         
  311.         rawdata = self.rawdata
  312.         while None:
  313.             c = rawdata[j:j + 1]
  314.             if not c:
  315.                 return -1
  316.             
  317.             if c == '>':
  318.                 return j + 1
  319.             
  320.             if c in '\'"':
  321.                 m = _declstringlit_match(rawdata, j)
  322.                 if not m:
  323.                     return -1
  324.                 
  325.                 j = m.end()
  326.                 continue
  327.             (name, j) = self._scan_name(j, declstartpos)
  328.             if j < 0:
  329.                 return j
  330.                 continue
  331.  
  332.     
  333.     def _parse_doctype_entity(self, i, declstartpos):
  334.         rawdata = self.rawdata
  335.         if rawdata[i:i + 1] == '%':
  336.             j = i + 1
  337.             while None:
  338.                 c = rawdata[j:j + 1]
  339.                 if not c:
  340.                     return -1
  341.                 
  342.                 if c.isspace():
  343.                     j = j + 1
  344.                     continue
  345.                 break
  346.         else:
  347.             j = i
  348.         (name, j) = self._scan_name(j, declstartpos)
  349.         if j < 0:
  350.             return j
  351.         
  352.         while None:
  353.             c = self.rawdata[j:j + 1]
  354.             if not c:
  355.                 return -1
  356.             
  357.             if c in '\'"':
  358.                 m = _declstringlit_match(rawdata, j)
  359.                 if m:
  360.                     j = m.end()
  361.                 else:
  362.                     return -1
  363.             if c == '>':
  364.                 return j + 1
  365.                 continue
  366.             (name, j) = self._scan_name(j, declstartpos)
  367.             if j < 0:
  368.                 return j
  369.                 continue
  370.  
  371.     
  372.     def _scan_name(self, i, declstartpos):
  373.         rawdata = self.rawdata
  374.         n = len(rawdata)
  375.         if i == n:
  376.             return (None, -1)
  377.         
  378.         m = _declname_match(rawdata, i)
  379.         if m:
  380.             s = m.group()
  381.             name = s.strip()
  382.             if i + len(s) == n:
  383.                 return (None, -1)
  384.             
  385.             return (name.lower(), m.end())
  386.         else:
  387.             self.updatepos(declstartpos, i)
  388.             self.error('expected name token at %r' % rawdata[declstartpos:declstartpos + 20])
  389.  
  390.     
  391.     def unknown_decl(self, data):
  392.         pass
  393.  
  394.  
  395.